﻿
using Anno.DynamicApi;
using System;
using System.Collections.Generic;
using System.IO;
using System.Text;
using System.Xml;
using System.Linq;

namespace Anno.DynamicApi
{
    /// <summary>
    /// 控制器构建信息列表 代码构建信息
    /// </summary>
    public class ControllerList
    {
        #region VAR
        static System.Collections.Concurrent.ConcurrentDictionary<string, ApiInfo> m_DicApiInfo 
            = new System.Collections.Concurrent.ConcurrentDictionary<string, ApiInfo>(StringComparer.CurrentCultureIgnoreCase);
        /// <summary>
        /// 接口信息集合
        /// </summary>
        public static System.Collections.Concurrent.ConcurrentDictionary<string, ApiInfo> DicApiInfo
        {
            get
            {
                if (m_DicApiInfo == null || m_DicApiInfo?.Count == 0)
                {
                    var msg = "";
                    if (!LoadApiControllers(out msg))
                        throw new Exception("LoadApiControllers Error:" + msg);
                    m_DicApiInfo = new System.Collections.Concurrent.ConcurrentDictionary<string, ApiInfo>(StringComparer.CurrentCultureIgnoreCase);
                }
                return m_DicApiInfo;
            }
        }
        static System.Collections.Concurrent.ConcurrentDictionary<string, RemoteUriInfo> m_DicBaseUri 
            = new System.Collections.Concurrent.ConcurrentDictionary<string, RemoteUriInfo>(StringComparer.CurrentCultureIgnoreCase);
        public static System.Collections.Concurrent.ConcurrentDictionary<string, RemoteUriInfo> DicBaseUri
        {
            get
            {
                if (m_DicBaseUri == null || m_DicBaseUri?.Count == 0)
                {
                    m_DicBaseUri = new System.Collections.Concurrent.ConcurrentDictionary<string, RemoteUriInfo>();
                    //var doc = new XmlDocument();
                    var xmlPath = System.IO.Path.Combine(PubFun.BaseDirectory, "ApiControllers.xml");
                    //如果没找到默认配置文件,则自动创建
                    if (!File.Exists(xmlPath))
                    {
                        return m_DicBaseUri;
                    }
                    //加载配置文件信息
                    //doc.Load(xmlPath);
                    if (SingleXml == null || SingleXml.xmlDoc == null)
                        SingleXml = new SingleXmlHelp(xmlPath, "configuration");
                    //------------------------------------------------------------------------
                    LoadBaseUris();
                }
                return m_DicBaseUri;
            }
        }
        public static void LoadBaseUris()
        {
            if (SingleXml == null || SingleXml.xmlDoc==null) return;
            var doc = SingleXml.xmlDoc;
            m_DicBaseUri = new System.Collections.Concurrent.ConcurrentDictionary<string, RemoteUriInfo>(StringComparer.CurrentCultureIgnoreCase);
            //------------------------------------------------------------------------
            #region 加载BaseUris
            try
            {
                //加载第三方调用地址
                var BaseUris = doc.SelectSingleNode("configuration/RemoteUris");
                if (BaseUris != null && BaseUris.HasChildNodes)
                {
                    foreach (XmlNode item in BaseUris.ChildNodes)
                    {
                        if (item.NodeType == XmlNodeType.Comment)// 判断等于注释时
                        {
                            continue;
                        }
                        var info = new RemoteUriInfo(item);
                        if (info.Name.IsNullOrEmpty())
                        {
                            continue;
                        }
                        m_DicBaseUri[info.Name] = info;
                    }
                }
            }
            catch { }
            #endregion
        }
        /// <summary>
        /// 命名空间Using列表
        /// </summary>
        public static List<string> DefaultUsing { get; set; } = new List<string>();
        public static void LoadReferences()
        {
            if (SingleXml == null || SingleXml.xmlDoc == null) return;
            var doc = SingleXml.xmlDoc;
            //------------------------------------------------------------------------
            #region 加载References
            try
            {
                //加载引用
                var References = doc.SelectSingleNode("configuration/References");
                if (References != null && References.HasChildNodes)
                {
                    DefaultUsing = new List<string>();
                    foreach (XmlNode item in References.ChildNodes)
                    {
                        if (item.NodeType == XmlNodeType.Comment)// 判断等于注释时
                        {
                            continue;
                        }
                        DefaultUsing.Add(PubFun.GetXmlNodeAttributeValue(item, "Include"));
                    }
                }
            }
            catch { }
            #endregion
        }
        /// <summary>
        /// 控制器构建信息
        /// </summary>
        public static List<ControllerInfo> ControllerBuilderInfos { get; set; } = new List<ControllerInfo>();
        /// <summary>
        /// XML 文档操作类
        /// </summary>
        public static SingleXmlHelp SingleXml { get; set; }

        static System.Collections.Concurrent.ConcurrentDictionary<string, RemoteUriInfo> m_DicSetingUri
           = new System.Collections.Concurrent.ConcurrentDictionary<string, RemoteUriInfo>(StringComparer.OrdinalIgnoreCase);
        public static System.Collections.Concurrent.ConcurrentDictionary<string, RemoteUriInfo> DicSetingUri
        {
            get
            {
                if (m_DicSetingUri == null || m_DicSetingUri?.Count == 0)
                {
                    m_DicSetingUri = new System.Collections.Concurrent.ConcurrentDictionary<string, RemoteUriInfo>();
                    //var doc = new XmlDocument();
                    var xmlPath = System.IO.Path.Combine(PubFun.BaseDirectory, "ApiControllers.xml");
                    //如果没找到默认配置文件,则自动创建
                    if (!File.Exists(xmlPath))
                    {
                        return m_DicSetingUri;
                    }
                    //加载配置文件信息
                    //doc.Load(xmlPath);
                    if (SingleXml == null || SingleXml.xmlDoc == null)
                        SingleXml = new SingleXmlHelp(xmlPath, "configuration");
                    //------------------------------------------------------------------------
                    LoadSettingUris();
                }
                return m_DicSetingUri;
            }
        }
        public static void LoadSettingUris()
        {
            if (SingleXml == null || SingleXml.xmlDoc == null) return;
            var doc = SingleXml.xmlDoc;

            m_DicSetingUri = new System.Collections.Concurrent.ConcurrentDictionary<string, RemoteUriInfo>(StringComparer.OrdinalIgnoreCase);
            //------------------------------------------------------------------------
            #region 加载SettingUris
            try
            {
                //加载环境调用地址
                var SettingUris = doc.SelectSingleNode("configuration/SettingUris");
                if (SettingUris != null && SettingUris.HasChildNodes)
                {
                    foreach (XmlNode item in SettingUris.ChildNodes)
                    {
                        if (item.NodeType == XmlNodeType.Comment)// 判断等于注释时
                        {
                            continue;
                        }
                        var info = new RemoteUriInfo(item);
                        if (info.Name.IsNullOrEmpty())
                        {
                            continue;
                        }
                        m_DicSetingUri[info.Name] = info;
                    }
                }
            }
            catch { }
            #endregion
        }
        #endregion

        #region GetBaseUri
        /// <summary>
        /// 获取baseUri
        /// </summary>
        /// <param name="baseUriName"></param>
        /// <param name="defValue"></param>
        /// <returns></returns>
        public static RemoteUriInfo GetBaseUri(string baseUriName, RemoteUriInfo defValue)
        {
            try
            {
                if (DicBaseUri.TryGetValue(baseUriName, out RemoteUriInfo val))
                {
                    if (!val.IsNullOrEmpty())
                        return val;
                }
            }
            catch
            {
            }
            return defValue;
        }
        #endregion

        /// <summary>
        /// 加载配置文件信息
        /// </summary>
        public static bool LoadApiControllers(out string msg, string apiConfigXml = "ApiControllers.xml")
        {
            msg = "";
            //var doc = new XmlDocument();
            var xmlPath = System.IO.Path.Combine(PubFun.BaseDirectory, apiConfigXml);
            //如果没找到默认配置文件,则自动创建
            if (!File.Exists(xmlPath))
            {
                msg = xmlPath + "文件不存在";
                return false;
            }
            ControllerBuilderInfos.Clear();
            m_DicApiInfo.Clear();
            m_DicBaseUri.Clear();

            //加载配置文件信息
            //doc.Load(xmlPath);
            SingleXml = new SingleXmlHelp(apiConfigXml, "configuration");
            var doc = SingleXml.xmlDoc;
            //------------------------------------------------------------------------
            #region 加载引用
            LoadReferences();
            #endregion
            #region 加载BaseUris
            LoadBaseUris();
            #endregion
            #region 加载SettingUris
            LoadSettingUris();
            #endregion

            //获取所有Controller子节点
            var controllerNodeList = doc.SelectNodes("configuration/Controller");
            if (controllerNodeList == null)
            {
                msg = "configuration/Controller节点";
                return false;
            }
            foreach (XmlNode controllerNode in controllerNodeList)
            {
                if (controllerNode == null || controllerNode.NodeType == XmlNodeType.Comment)// 判断等于注释时
                {
                    continue;
                }
                //1. 获得控制器属性 controller
                //获得controller属性
                var controller = new ControllerInfo(controllerNode);
                //2. 获得所有Api节点
                controller.ApiInfoList?.ForEach(apiInfo => { m_DicApiInfo[apiInfo.KeyWord] = apiInfo; });

                ControllerBuilderInfos.Add(controller);
            }

            return true;
        }
        ///// <summary>
        ///// 加载配置文件信息
        ///// </summary>
        //public bool LoadApiControllers2(out string msg, string apiConfigXml = "ApiControllers.xml")
        //{
        //    msg = "";
        //    var doc = new XmlDocument();
        //    var xmlPath = System.IO.Path.Combine(PubFun.BaseDirectory, apiConfigXml);
        //    //如果没找到默认配置文件,则自动创建
        //    if (!File.Exists(xmlPath))
        //    {
        //        msg = xmlPath + "文件不存在";
        //        return false;
        //    }
        //    //加载配置文件信息
        //    doc.Load(xmlPath);
        //    //------------------------------------------------------------------------
        //    #region 加载引用
        //    loadReferences(doc);
        //    #endregion
        //    #region 加载BaseUris
        //    loadBaseUris(doc);
        //    #endregion

        //    //选择文档中所有的Controller的子节点
        //    var controllerNodeList = doc.SelectNodes("configuration/Controller");
        //    if (controllerNodeList == null)
        //    {
        //        msg = "configuration/Controller节点";
        //        return false;
        //    }
        //    foreach (XmlNode controllerNode in controllerNodeList)
        //    {
        //        if (controllerNode == null || controllerNode.NodeType == XmlNodeType.Comment)// 判断等于注释时
        //        {
        //            continue;
        //        }
        //        #region 1. 获得控制器属性 controller
        //        //获得controller属性
        //        var controller = new ControllerInfo(controllerNode);
        //        if (controller.ControllerName.IsNullOrEmpty())
        //        {
        //            msg = "<Controller Name属性不能为空";
        //            return false;
        //        }
        //        //if (controller.RoutePrefix.IsNullOrEmpty())
        //        //{
        //        //    msg = "<Controller RoutePrefix属性不能为空";
        //        //    return false;
        //        //}
        //        //if (controller.ControllerType == 1)
        //        //{
        //        //    if (controller.assemblyTypeName.IsNullOrEmpty() || controller.contractTypName.IsNullOrEmpty())
        //        //    {
        //        //        msg = "ControllerType==1 时 assemblyTypeName和contractTypName 属性不能为空";
        //        //        return false;
        //        //    }
        //        //}
        //        #endregion

        //        #region 2. 获得所有Api节点
        //        //获得controllerNode的所有Api节点
        //        var apiNodeList = controllerNode.ChildNodes;
        //        if (apiNodeList == null)
        //        {
        //            msg = "<Controller Name=" + controller.ControllerName + " 下无 <Api/>子节点";
        //            return false;
        //        }
        //        controller.ApiInfoList = new List<ApiInfo>();

        //        foreach (XmlNode apiNode in apiNodeList)
        //        {
        //            #region 2.1. Api Info
        //            if (apiNode.NodeType == XmlNodeType.Comment)// 判断等于注释时
        //            {
        //                continue;
        //            }
        //            var apiName = PubFun.GetXmlNodeAttributeValue(apiNode, "Name").Trim('.');
        //            if (apiName.IsNullOrEmpty())
        //            {
        //                msg = "<Controller Name=" + controller.ControllerName + " 的 <Api Name属性不能为空";
        //                return false;
        //            }
        //            if (controller.ApiInfoList.Exists(f => f.ApiName.Equals(apiName)))
        //            {
        //                msg = $"<Controller Name={controller.ControllerName} 的 <Api Name={apiName}/>名称重复";
        //                return false;
        //            }
        //            var apiInfo = new ApiInfo(apiNode, controller);

        //            var apiError = "<Api Name=" + apiInfo.ApiName;
        //            #endregion

        //            #region 2.2. 获得Executors子节点
        //            var ExecutorsNode = apiNode.SelectSingleNode("Executors");
        //            if (ExecutorsNode == null)
        //            {
        //                msg = apiError + " 下无 <Executors/>子节点";
        //                return false;
        //            }
        //            var ExecutorList = ExecutorsNode.ChildNodes;
        //            if (ExecutorList == null)
        //            {
        //                msg = apiError + " 下无 <Executors><Executor/></Executors>子节点";
        //                return false;
        //            }
        //            apiInfo.ExecutorList = new List<BaseExecutor>();
        //            foreach (XmlNode ExecutorNode in ExecutorList)
        //            {
        //                #region 2.2.1. Executor
        //                var tacp = getExecutor(apiError, apiNode, ExecutorNode, apiInfo, controller, out msg);
        //                if (tacp.Item1 == false) return false;
        //                if (tacp.Item2 == null) continue;

        //                #endregion

        //                #region 2.2.1. Executor old
        //                //if (ExecutorNode.NodeType == XmlNodeType.Comment)// 判断等于注释时
        //                //{
        //                //    continue;
        //                //}
        //                //var pointType = ExecutorNode.GetXmlNodeAttributeValue( "ExecType");
        //                //if (pointType.IsNullOrEmpty())
        //                //{
        //                //    msg = apiError + " 的 <Executor ExecType属性不能为空";
        //                //    return false;
        //                //}
        //                //BaseExecutor acp = null;
        //                //#region SqlTpl
        //                //if (pointType == ExecutorType.SqlTpl.ToString())
        //                //{
        //                //    var SqlTpl = new SqlTplExecutor(ExecutorNode, apiInfo);
        //                //    if (SqlTpl.Sql.IsNullOrEmpty_())
        //                //    {
        //                //        msg = apiError + " SqlTpl 的 <Executor ExecType=SqlTpl 属性不能为空";
        //                //        return false;
        //                //    }
        //                //    if (string.IsNullOrWhiteSpace(SqlTpl.DBName))
        //                //    {
        //                //        SqlTpl.DBName = controller.DefaultDBName;
        //                //    }
        //                //    #region 获得所有Outputs节点
        //                //    SqlTpl.OutputList = new List<ApiOutputInfo>();
        //                //    var outputInfosNode = ExecutorNode.SelectSingleNode("Outputs");
        //                //    if (outputInfosNode == null)
        //                //    {
        //                //        outputInfosNode = apiNode.SelectSingleNode("Outputs");
        //                //    }
        //                //    if (outputInfosNode == null)
        //                //    {
        //                //        outputInfosNode = ExecutorNode.SelectSingleNode("Output");

        //                //        //var lastCMP = apiInfo.ExecutorList.LastOrDefault();
        //                //        //if (lastCMP != null && lastCMP.ExecType == ExecutorType.SqlTpl)
        //                //        if (outputInfosNode == null)
        //                //        {
        //                //            msg = apiError + "<Executor ExecType=SqlTpl 下无 <Outputs/>子节点";
        //                //            return false;
        //                //        }
        //                //        else
        //                //        {
        //                //            var ret = setOutput(SqlTpl, apiError, outputInfosNode, apiInfo, out msg);
        //                //            if (ret == false) return false;
        //                //        }
        //                //    }
        //                //    else
        //                //    {
        //                //        var outputInfoList = outputInfosNode.ChildNodes;
        //                //        if (outputInfoList == null)
        //                //        {
        //                //            msg = apiError + " 下无 <Output/>子节点";
        //                //            return false;
        //                //        }
        //                //        foreach (XmlNode outputNode in outputInfoList)
        //                //        {
        //                //            #region OutputInfo
        //                //            if (outputNode.NodeType == XmlNodeType.Comment)// 判断等于注释时
        //                //            {
        //                //                continue;
        //                //            }
        //                //            var ret = setOutput(SqlTpl, apiError, outputNode, apiInfo, out msg);
        //                //            if (ret == false) return false;
        //                //            #region Output
        //                //            //var output = new ApiOutputInfo(outputNode);
        //                //            //output.ApiName = apiInfo.ApiName;
        //                //            //if (output.OutputName.IsNullOrEmpty())
        //                //            //{
        //                //            //    msg = apiError + " 的 <Output OutputName属性不能为空";
        //                //            //    return false;
        //                //            //}
        //                //            //if (SqlTpl.OutputList.Exists(f => f.OutputName.Equals(output.OutputName)))
        //                //            //{
        //                //            //    msg = $"{apiError} 的 <Output OutputName={output.OutputName}/>出参名称重复";
        //                //            //    return false;
        //                //            //}

        //                //            //SqlTpl.OutputList.Add(output);
        //                //            //#endregion

        //                //            //#region FieldInfo
        //                //            //var fieldInfoList = outputNode.ChildNodes;
        //                //            //if (fieldInfoList != null)
        //                //            //{
        //                //            //    output.ApiInputInfoList = new List<ApiFieldInfo>();
        //                //            //    foreach (XmlNode fieldInfoNode in fieldInfoList)
        //                //            //    {
        //                //            //        if (fieldInfoNode.NodeType == XmlNodeType.Comment)// 判断等于注释时
        //                //            //        {
        //                //            //            continue;
        //                //            //        }
        //                //            //        var fieldInfo = new ApiFieldInfo(fieldInfoNode);
        //                //            //        if (fieldInfo.Name.IsNullOrEmpty())
        //                //            //        {
        //                //            //            msg = $"{apiError } OutputName={output.OutputName} 的 <FieldInfo Name属性不能为空";
        //                //            //            return false;
        //                //            //        }
        //                //            //        if (output.ApiInputInfoList.Exists(f => f.Name.Equals(fieldInfo.Name)))
        //                //            //        {
        //                //            //            msg = $"{apiError} OutputName={output.OutputName} 的 <FieldInfo Name={apiName}/>出参实体的字段名称重复";
        //                //            //            return false;
        //                //            //        }
        //                //            //        output.ApiInputInfoList.Add(fieldInfo);

        //                //            //        var ret = setSubField("FieldInfo", apiError, fieldInfoNode, fieldInfo, out msg);
        //                //            //        if (ret == false) return false;
        //                //            //    }
        //                //            //}
        //                //            #endregion
        //                //            #endregion
        //                //        }
        //                //    }
        //                //    #endregion

        //                //    acp = SqlTpl;
        //                //}
        //                //#endregion
        //                //#region RemoteApi
        //                //else if (pointType == ExecutorType.RemoteApi.ToString())
        //                //{
        //                //    var RemoteApi = new RemoteApiExecutor(ExecutorNode, apiInfo);
        //                //    if (RemoteApi.BaseUri.IsNullOrEmpty())
        //                //    {
        //                //        msg = apiError + " 的 <Executor BaseUri属性不能为空";
        //                //        return false;
        //                //    }
        //                //    acp = RemoteApi;
        //                //}
        //                //#endregion
        //                //#region RemoteWS
        //                //else if (pointType == ExecutorType.RemoteWS.ToString())
        //                //{
        //                //    var RemoteWS = new RemoteWSExecutor(ExecutorNode, apiInfo);
        //                //    if (RemoteWS.BaseUri.IsNullOrEmpty())
        //                //    {
        //                //        msg = apiError + " 的 <Executor BaseUri属性不能为空";
        //                //        return false;
        //                //    }
        //                //    acp = RemoteWS;
        //                //}
        //                //#endregion
        //                //#region LocalDLL
        //                //else if (pointType == ExecutorType.LocalDLL.ToString())
        //                //{
        //                //    var LocalDLL = new LocalDLLExecutor(ExecutorNode, apiInfo);
        //                //    if (LocalDLL.FullClassName.IsNullOrEmpty())
        //                //    {
        //                //        msg = apiError + " 的 <Executor FullClassName属性不能为空";
        //                //        return false;
        //                //    }
        //                //    acp = LocalDLL;
        //                //}
        //                //#endregion
        //                //#region CSScript
        //                //else if (pointType == ExecutorType.CSScript.ToString())
        //                //{
        //                //    var csScript = new CSScriptExecutor(ExecutorNode, apiInfo);
        //                //    if (csScript.CSScriptCode.IsNullOrEmpty())
        //                //    {
        //                //        msg = apiError + " 的 <Executor CSScriptCode属性不能为空";
        //                //        return false;
        //                //    }
        //                //    acp = csScript;
        //                //}
        //                //#endregion

        //                //if (acp.IsNullOrEmpty())
        //                //{
        //                //    msg = apiError + " 的 <Executor 属性设置有误";
        //                //    return false;
        //                //}
        //                //#endregion

        //                //#region 2.2.2. 获得所有Executor Input节点
        //                //var parameterList = ExecutorNode.ChildNodes;
        //                //if (parameterList != null)
        //                //{
        //                //    acp.ApiInputInfoList = new List<ApiFieldInfo>();
        //                //    acp.Conditions = new ExecConditions();
        //                //    foreach (XmlNode parameterNode in parameterList)
        //                //    {
        //                //        if (parameterNode.NodeType == XmlNodeType.Comment)// 判断等于注释时
        //                //        {
        //                //            continue;
        //                //        }
        //                //        var localName = parameterNode.LocalName;
        //                //        #region input 入参
        //                //        if (localName.ToLower() == "input")//入参
        //                //        {
        //                //            var ret = setInput(acp, apiError, parameterNode, apiInfo, out msg);
        //                //            if (ret == false) return false;
        //                //            //var parameter = new ApiFieldInfo(parameterNode);
        //                //            //if (parameter.Name.IsNullOrEmpty())
        //                //            //{
        //                //            //    msg = apiError + " 的 <Parameter Name属性不能为空";
        //                //            //    return false;
        //                //            //}
        //                //            //if (acp.ApiInputInfoList.Exists(f => f.Name.Equals(parameter.Name)))
        //                //            //{
        //                //            //    msg = $"{apiError} 的 <Parameter Name={apiName}/>入参字段名称重复";
        //                //            //    return false;
        //                //            //}

        //                //            //acp.ApiInputInfoList.Add(parameter);

        //                //            //var ret = setSubField("Parameter", apiError, parameterNode, parameter, out msg);
        //                //            //if (ret == false) return false;
        //                //        }
        //                //        #endregion
        //                //        #region inputs 入参集合
        //                //        else if (localName.ToLower() == "inputs")//入参集合
        //                //        {
        //                //            var inputList = parameterNode.ChildNodes;
        //                //            if (inputList != null)
        //                //            {
        //                //                foreach (XmlNode inputNode in inputList)
        //                //                {
        //                //                    if (inputNode.NodeType == XmlNodeType.Comment)// 判断等于注释时
        //                //                    {
        //                //                        continue;
        //                //                    }
        //                //                    if (inputNode.LocalName.ToLower() == "input")//入参
        //                //                    {
        //                //                        var ret = setInput(acp, apiError, inputNode, apiInfo, out msg);
        //                //                        if (ret == false) return false;
        //                //                        //var parameter = new ApiFieldInfo(inputNode);
        //                //                        //if (parameter.Name.IsNullOrEmpty())
        //                //                        //{
        //                //                        //    msg = apiError + " 的 <Parameter Name属性不能为空";
        //                //                        //    return false;
        //                //                        //}
        //                //                        //if (acp.ApiInputInfoList.Exists(f => f.Name.Equals(parameter.Name)))
        //                //                        //{
        //                //                        //    msg = $"{apiError} 的 <Parameter Name={apiName}/>入参字段名称重复";
        //                //                        //    return false;
        //                //                        //}

        //                //                        //acp.ApiInputInfoList.Add(parameter);

        //                //                        //var ret = setSubField("Parameter", apiError, inputNode, parameter, out msg);
        //                //                        //if (ret == false) return false;
        //                //                    }
        //                //                }
        //                //            }
        //                //        }
        //                //        #endregion
        //                //        #region output 出参
        //                //        //只有SqlTpl类型的执行者才有出参配置
        //                //        if (pointType == ExecutorType.SqlTpl.ToString() && localName.ToLower() == "output")//入参
        //                //        {
        //                //            var ret = setOutput(acp as SqlTplExecutor, apiError, parameterNode, apiInfo, out msg);
        //                //            if (ret == false) return false;
        //                //        }
        //                //        #endregion
        //                //        #region conditions 调用过滤条件
        //                //        else if (localName.ToLower() == "conditions")//调用过滤条件
        //                //        {
        //                //            acp.Conditions.ConditionType = parameterNode.GetXmlNodeAttributeValue("ConditionType", "AND").ToEnum_<ConditionType>();
        //                //            var conditionList = parameterNode.ChildNodes;
        //                //            if (conditionList != null)
        //                //            {
        //                //                foreach (XmlNode conditionNode in conditionList)
        //                //                {
        //                //                    var condition = new ExecCondition(conditionNode);
        //                //                    if (condition.FiledPath.IsNullOrEmpty())
        //                //                    {
        //                //                        msg = apiError + " 的 <Condition FiledPath属性不能为空";
        //                //                        return false;
        //                //                    }
        //                //                    if (condition.Operand.IsNullOrEmpty())
        //                //                    {
        //                //                        msg = apiError + " 的 <Condition Operand属性不能为空";
        //                //                        return false;
        //                //                    }
        //                //                    acp.Conditions.Add(condition);
        //                //                }
        //                //            }
        //                //        }
        //                //        #endregion
        //                //    }
        //                //}
        //                #endregion

        //                apiInfo.ExecutorList.Add(tacp.Item2);
        //            }
        //            #endregion

        //            #region  2.3. 获得Outputs节点
        //            //var outputInfosNode = apiNode.SelectSingleNode("Outputs");
        //            //if (outputInfosNode == null)
        //            //{
        //            //    var lastCMP = apiInfo.ExecutorList[apiInfo.ExecutorList.Count - 1];
        //            //    if (lastCMP != null && lastCMP.ExecType == ExecutorType.SqlTpl)
        //            //    {
        //            //        msg = apiError + " 下无 <Outputs/>子节点";
        //            //        return false;
        //            //    }
        //            //}
        //            #region 获得所有Output节点
        //            //if (outputInfosNode != null)
        //            //{
        //            //    var outputInfoList = outputInfosNode.ChildNodes;
        //            //    if (outputInfoList == null)
        //            //    {
        //            //        msg = apiError + " 下无 <Output/>子节点";
        //            //        return false;
        //            //    }
        //            //    apiInfo.OutputList = new List<ApiOutputInfo>();
        //            //    foreach (XmlNode outputNode in outputInfoList)
        //            //    {
        //            //        #region OutputInfo
        //            //        if (outputNode.NodeType == XmlNodeType.Comment)// 判断等于注释时
        //            //        {
        //            //            continue;
        //            //        }
        //            //        #region Output
        //            //        var output = new ApiOutputInfo(outputNode);
        //            //        output.ApiName = apiInfo.ApiName;
        //            //        if (output.OutputName.IsNullOrEmpty())
        //            //        {
        //            //            msg = apiError + " 的 <Output OutputName属性不能为空";
        //            //            return false;
        //            //        }
        //            //        if (apiInfo.OutputList.Exists(f => f.OutputName.Equals(output.OutputName)))
        //            //        {
        //            //            msg = $"{apiError} 的 <Output OutputName={output.OutputName}/>出参名称重复";
        //            //            return false;
        //            //        }
        //            //        if (output.DataSoureIndex < 0) output.DataSoureIndex = 0;

        //            //        apiInfo.OutputList.Add(output);
        //            //        #endregion

        //            //        #region FieldInfo
        //            //        var fieldInfoList = outputNode.ChildNodes;
        //            //        if (fieldInfoList != null)
        //            //        {
        //            //            output.ApiInputInfoList = new List<ApiFieldInfo>();
        //            //            foreach (XmlNode fieldInfoNode in fieldInfoList)
        //            //            {
        //            //                if (fieldInfoNode.NodeType == XmlNodeType.Comment)// 判断等于注释时
        //            //                {
        //            //                    continue;
        //            //                }
        //            //                var fieldInfo = new ApiFieldInfo(fieldInfoNode);
        //            //                if (fieldInfo.Name.IsNullOrEmpty())
        //            //                {
        //            //                    msg = $"{apiError } OutputName={output.OutputName} 的 <FieldInfo Name属性不能为空";
        //            //                    return false;
        //            //                }
        //            //                if (output.ApiInputInfoList.Exists(f => f.Name.Equals(fieldInfo.Name)))
        //            //                {
        //            //                    msg = $"{apiError} OutputName={output.OutputName} 的 <FieldInfo Name={apiName}/>出参实体的字段名称重复";
        //            //                    return false;
        //            //                }
        //            //                output.ApiInputInfoList.Add(fieldInfo);

        //            //                var ret = setSubField("FieldInfo", apiError, fieldInfoNode, fieldInfo, out msg);
        //            //                if (ret == false) return false;
        //            //            }
        //            //        }
        //            //        #endregion
        //            //        #endregion
        //            //    }
        //            //}
        //            #endregion
        //            #endregion

        //            controller.ApiInfoList.Add(apiInfo);
        //            m_DicApiInfo[apiInfo.KeyWord] = apiInfo;
        //        }
        //        #endregion

        //        this.ControllerBuilderInfos.Add(controller);
        //    }

        //    return true;
        //}

        //private Tuple<bool, BaseExecutor> getExecutor(string apiError, XmlNode apiNode, XmlNode ExecutorNode, ApiInfo apiInfo, ControllerInfo controller, out string msg)
        //{
        //    msg = "";
        //    BaseExecutor acp = null;
        //    #region 2.2.1. Executor
        //    if (ExecutorNode.NodeType == XmlNodeType.Comment)// 判断等于注释时
        //    {
        //        return Tuple.Create(true, acp);
        //    }
        //    var pointType = ExecutorNode.GetXmlNodeAttributeValue("ExecType");
        //    if (pointType.IsNullOrEmpty())
        //    {
        //        msg = apiError + " 的 <Executor ExecType属性不能为空";
        //        return Tuple.Create(false, acp);
        //    }
        //    #region SqlTpl
        //    if (pointType == ExecutorType.SqlTpl.ToString())
        //    {
        //        var SqlTpl = new SqlTplExecutor(ExecutorNode, apiInfo);
        //        if (SqlTpl.Sql.IsNullOrEmpty_())
        //        {
        //            msg = apiError + " SqlTpl 的 <Executor ExecType=SqlTpl 属性不能为空";
        //            return Tuple.Create(false, acp);
        //        }
        //        if (string.IsNullOrWhiteSpace(SqlTpl.DBName))
        //        {
        //            SqlTpl.DBName = controller.DefaultDBName;
        //        }
        //        #region 获得所有Outputs节点
        //        SqlTpl.OutputList = new List<ApiOutputInfo>();
        //        var outputInfosNode = ExecutorNode.SelectSingleNode("Outputs");
        //        if (apiNode != null && outputInfosNode == null)
        //        {
        //            outputInfosNode = apiNode.SelectSingleNode("Outputs");
        //        }
        //        if (outputInfosNode == null)
        //        {
        //            outputInfosNode = ExecutorNode.SelectSingleNode("Output");

        //            //var lastCMP = apiInfo.ExecutorList.LastOrDefault();
        //            //if (lastCMP != null && lastCMP.ExecType == ExecutorType.SqlTpl)
        //            if (outputInfosNode == null)
        //            {
        //                msg = apiError + "<Executor ExecType=SqlTpl 下无 <Outputs/>子节点";
        //                return Tuple.Create(false, acp);
        //            }
        //            else
        //            {
        //                var ret = setOutput(SqlTpl, apiError, outputInfosNode, apiInfo, out msg);
        //                if (ret == false) return Tuple.Create(false, acp);
        //            }
        //        }
        //        else
        //        {
        //            var outputInfoList = outputInfosNode.ChildNodes;
        //            if (outputInfoList == null)
        //            {
        //                msg = apiError + " 下无 <Output/>子节点";
        //                return Tuple.Create(false, acp);
        //            }
        //            foreach (XmlNode outputNode in outputInfoList)
        //            {
        //                #region OutputInfo
        //                if (outputNode.NodeType == XmlNodeType.Comment)// 判断等于注释时
        //                {
        //                    continue;
        //                }
        //                var ret = setOutput(SqlTpl, apiError, outputNode, apiInfo, out msg);
        //                if (ret == false) return Tuple.Create(false, acp);

        //                #endregion
        //            }
        //        }
        //        #endregion

        //        acp = SqlTpl;
        //    }
        //    #endregion
        //    #region RemoteApi
        //    else if (pointType == ExecutorType.RemoteApi.ToString())
        //    {
        //        var RemoteApi = new RemoteApiExecutor(ExecutorNode, apiInfo);
        //        if (RemoteApi.BaseUri.IsNullOrEmpty())
        //        {
        //            msg = apiError + " 的 <Executor BaseUri属性不能为空";
        //            return Tuple.Create(false, acp);
        //        }
        //        acp = RemoteApi;
        //    }
        //    #endregion
        //    #region RemoteWS
        //    else if (pointType == ExecutorType.RemoteWS.ToString())
        //    {
        //        var RemoteWS = new RemoteWSExecutor(ExecutorNode, apiInfo);
        //        if (RemoteWS.BaseUri.IsNullOrEmpty())
        //        {
        //            msg = apiError + " 的 <Executor BaseUri属性不能为空";
        //            return Tuple.Create(false, acp);
        //        }
        //        acp = RemoteWS;
        //    }
        //    #endregion
        //    #region LocalDLL
        //    else if (pointType == ExecutorType.LocalDLL.ToString())
        //    {
        //        var LocalDLL = new LocalDLLExecutor(ExecutorNode, apiInfo);
        //        if (LocalDLL.FullClassName.IsNullOrEmpty())
        //        {
        //            msg = apiError + " 的 <Executor FullClassName属性不能为空";
        //            return Tuple.Create(false, acp);
        //        }
        //        acp = LocalDLL;
        //    }
        //    #endregion
        //    #region CSScript
        //    else if (pointType == ExecutorType.CSScript.ToString())
        //    {
        //        var csScript = new CSScriptExecutor(ExecutorNode, apiInfo);
        //        if (csScript.CSScriptCode.IsNullOrEmpty())
        //        {
        //            msg = apiError + " 的 <Executor CSScriptCode属性不能为空";
        //            return Tuple.Create(false, acp);
        //        }
        //        acp = csScript;
        //    }
        //    #endregion

        //    if (acp.IsNullOrEmpty())
        //    {
        //        msg = apiError + " 的 <Executor ExecType= 属性设置有误";
        //        return Tuple.Create(false, acp);
        //    }
        //    #endregion

        //    #region 2.2.2. 获得执行者所属 Input、output、conditions、Executor节点
        //    var parameterList = ExecutorNode.ChildNodes;
        //    if (parameterList != null)
        //    {
        //        acp.ApiInputInfoList = new List<ApiFieldInfo>();
        //        acp.Conditions = new ExecConditions();
        //        foreach (XmlNode parameterNode in parameterList)
        //        {
        //            if (parameterNode.NodeType == XmlNodeType.Comment)// 判断等于注释时
        //            {
        //                continue;
        //            }
        //            var localName = parameterNode.LocalName.NullToStr();
        //            #region input 入参
        //            if (localName.Equals("input", StringComparison.OrdinalIgnoreCase))//入参
        //            {
        //                var ret = setInput(acp, apiError, parameterNode, apiInfo, out msg);
        //                if (ret == false) return Tuple.Create(false, acp);
        //            }
        //            #endregion
        //            #region inputs 入参集合
        //            else if (localName.Equals("inputs", StringComparison.OrdinalIgnoreCase))//入参集合
        //            {
        //                var inputList = parameterNode.ChildNodes;
        //                if (inputList != null)
        //                {
        //                    foreach (XmlNode inputNode in inputList)
        //                    {
        //                        if (inputNode.NodeType == XmlNodeType.Comment)// 判断等于注释时
        //                        {
        //                            continue;
        //                        }
        //                        if (inputNode.LocalName.NullToStr().Equals("input", StringComparison.OrdinalIgnoreCase))//入参
        //                        {
        //                            var ret = setInput(acp, apiError, inputNode, apiInfo, out msg);
        //                            if (ret == false) return Tuple.Create(false, acp);
        //                        }
        //                    }
        //                }
        //            }
        //            #endregion
        //            #region output 出参
        //            //只有SqlTpl类型的执行者才有出参配置
        //            else if (pointType == ExecutorType.SqlTpl.ToString() && localName.Equals("output", StringComparison.OrdinalIgnoreCase))//入参
        //            {
        //                var ret = setOutput(acp as SqlTplExecutor, apiError, parameterNode, apiInfo, out msg);
        //                if (ret == false) return Tuple.Create(false, acp);
        //            }
        //            #endregion
        //            #region conditions 调用过滤条件
        //            else if (localName.Equals("conditions", StringComparison.OrdinalIgnoreCase))//调用过滤条件
        //            {
        //                acp.Conditions.ConditionType = parameterNode.GetXmlNodeAttributeValue("ConditionType", "AND").ToEnum_<ConditionType>();
        //                var conditionList = parameterNode.ChildNodes;
        //                if (conditionList != null)
        //                {
        //                    foreach (XmlNode conditionNode in conditionList)
        //                    {
        //                        var condition = new ExecCondition(conditionNode);
        //                        if (condition.FiledPath.IsNullOrEmpty())
        //                        {
        //                            msg = apiError + " 的 <Condition FiledPath属性不能为空";
        //                            return Tuple.Create(false, acp);
        //                        }
        //                        if (condition.Operand.IsNullOrEmpty())
        //                        {
        //                            msg = apiError + " 的 <Condition Operand属性不能为空";
        //                            return Tuple.Create(false, acp);
        //                        }
        //                        acp.Conditions.Add(condition);
        //                    }
        //                }
        //            }
        //            #endregion

        //            #region Executor 下级执行者
        //            else if (localName.Equals("Executor", StringComparison.OrdinalIgnoreCase))//下级执行者
        //            {
        //                var tacp = getExecutor(apiError, null, parameterNode, apiInfo, controller, out msg);
        //                if (tacp.Item1 == false) return Tuple.Create(false, acp);
        //                if (tacp.Item2 != null)
        //                {
        //                    if (acp.NextExecutors == null)
        //                        acp.NextExecutors = new List<BaseExecutor>();
        //                    acp.NextExecutors.Add(tacp.Item2);
        //                }
        //            }
        //            #endregion
        //        }
        //    }
        //    #endregion

        //    return Tuple.Create(true, acp);
        //}

        //private bool setInput(BaseExecutor acp, string apiError, XmlNode inputNode, ApiInfo apiInfo, out string msg)
        //{
        //    msg = "";
        //    if (inputNode.NodeType == XmlNodeType.Comment)// 判断等于注释时
        //    {
        //        return true;
        //    }
        //    var localName = inputNode.LocalName;
        //    #region input 入参
        //    if (localName.ToLower() == "input")//入参
        //    {
        //        var parameter = new ApiFieldInfo(inputNode);
        //        if (parameter.Name.IsNullOrEmpty())
        //        {
        //            msg = apiError + " 的 <Parameter Name属性不能为空";
        //            return false;
        //        }
        //        if (acp.ApiInputInfoList == null) acp.ApiInputInfoList = new List<ApiFieldInfo>();
        //        if (acp.ApiInputInfoList.Exists(f => f.Name.Equals(parameter.Name)))
        //        {
        //            acp.ApiInputInfoList.RemoveAll(f => f.Name.Equals(parameter.Name));
        //            //msg = $"{apiError} 的 <Parameter Name={apiInfo.ApiName}/>入参字段名称重复";
        //            //return false;
        //        }

        //        acp.ApiInputInfoList.Add(parameter);

        //        var ret = setSubField("Parameter", apiError, inputNode, parameter, out msg);
        //        if (ret == false) return false;
        //    }
        //    #endregion
        //    return true;
        //}
        //private bool setOutput(SqlTplExecutor sqlTpl, string apiError, XmlNode outputNode, ApiInfo apiInfo, out string msg)
        //{
        //    msg = "";
        //    #region OutputInfo
        //    if (outputNode.NodeType == XmlNodeType.Comment)// 判断等于注释时
        //    {
        //        return true;
        //    }
        //    #region Output
        //    var output = new ApiOutputInfo(outputNode);
        //    output.ApiName = apiInfo.ApiName;
        //    if (output.OutputName.IsNullOrEmpty())
        //    {
        //        msg = apiError + " 的 <Output OutputName属性不能为空";
        //        return false;
        //    }
        //    if (sqlTpl.OutputList == null) sqlTpl.OutputList = new List<ApiOutputInfo>();
        //    if (sqlTpl.OutputList.Exists(f => f.OutputName.Equals(output.OutputName)))
        //    {
        //        sqlTpl.OutputList.RemoveAll(f => f.OutputName.Equals(output.OutputName));
        //        //msg = $"{apiError} 的 <Output OutputName={output.OutputName}/>出参名称重复";
        //        //return true;
        //    }

        //    sqlTpl.OutputList.Add(output);
        //    #endregion

        //    #region FieldInfo
        //    var fieldInfoList = outputNode.ChildNodes;
        //    if (fieldInfoList != null)
        //    {
        //        output.ApiInputInfoList = new List<ApiFieldInfo>();
        //        foreach (XmlNode fieldInfoNode in fieldInfoList)
        //        {
        //            if (fieldInfoNode.NodeType == XmlNodeType.Comment)// 判断等于注释时
        //            {
        //                continue;
        //            }
        //            var fieldInfo = new ApiFieldInfo(fieldInfoNode);
        //            if (fieldInfo.Name.IsNullOrEmpty())
        //            {
        //                msg = $"{apiError } OutputName={output.OutputName} 的 <FieldInfo Name属性不能为空";
        //                return false;
        //            }
        //            if (output.ApiInputInfoList.Exists(f => f.Name.Equals(fieldInfo.Name)))
        //            {
        //                output.ApiInputInfoList.RemoveAll(f => f.Name.Equals(fieldInfo.Name));

        //                //msg = $"{apiError} OutputName={output.OutputName} 的 <FieldInfo Name={apiInfo.ApiName}/>出参实体的字段名称重复";
        //                //return false;
        //            }
        //            output.ApiInputInfoList.Add(fieldInfo);

        //            var ret = setSubField("FieldInfo", apiError, fieldInfoNode, fieldInfo, out msg);
        //            if (ret == false) return false;
        //        }
        //    }
        //    #endregion
        //    #endregion

        //    return true;
        //}
        ///// <summary>
        ///// 获取字段子节点
        ///// </summary>
        ///// <param name="apiError"></param>
        ///// <param name="fieldNode"></param>
        ///// <param name="pfieldNode"></param>
        ///// <param name="msg"></param>
        ///// <returns></returns>
        //private bool setSubField(string name ,string apiError, XmlNode fieldNode, ApiFieldInfo pfieldNode, out string msg)
        //{
        //    msg = "";
        //    var parameterList = fieldNode.ChildNodes;
        //    if (parameterList != null)
        //    {
        //        pfieldNode.SubFieldInfoList = new List<ApiFieldInfo>();
        //        foreach (XmlNode parameterNode in parameterList)
        //        {
        //            if (parameterNode.NodeType == XmlNodeType.Comment)// 判断等于注释时
        //            {
        //                continue;
        //            }
        //            var parameter = new ApiFieldInfo(parameterNode);
        //            if (parameter.Name.IsNullOrEmpty())
        //            {
        //                msg = apiError + " 的 <{name} Name属性不能为空";
        //                return false;
        //            }
        //            if (pfieldNode.SubFieldInfoList.Exists(f => f.Name.Equals(parameter.Name)))
        //            {
        //                msg = $"{apiError} 的 <{name} Name={pfieldNode.Name}/>子节点字段名称重复";
        //                return false;
        //            }

        //            pfieldNode.SubFieldInfoList.Add(parameter);

        //            var ret = setSubField(name,apiError, parameterNode, parameter, out msg);
        //            if (ret == false) return false;
        //        }
        //    }
        //    return true;
        //}
    }
}
